<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Utilisation de JavaMail - 2ème partie - Articles - 1/1 - Java &amp; Solaris par le Laboratoire SUPINFO des technologies Sun </title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
        <keywords>javamail,howto,tutoriel,email,pop,smtp,Java,Java SE,Web,utilisation,de,javamail,2eme,partie,articles,1,1,certification,sun,java,solaris,articles,essentiels,tips,astuces,codes,exemple,tutorial,developpement,jsp,servlet,jdbc,jdo,j2se,j2ee,laboratoire</keywords>
        <author>Julie Muesser</author>
    </head>
    <body>
        <div class="chapter">
            <h1>Utilisation de JavaMail - 2ème partie</h1>
        </div>
        <div class="chapter">
            <h2>Introduction</h2>
            <p>
                Cet article est la suite d'un précédent article sur javamail (
                <a href="http://www.labo-sun.com/resource-FR-articles-603-0-java-j2se-web-utilisation-de-javamail.htm" target="_about">Voir l'article</a>
                ). Il a pour but de montrer les différentes utilisations des classes afin d'effectuer différentes tâches comme l'envoi et la réception de message, les pièces jointes etc...
            </p>
        </div>
        <div class="chapter">
            <h2>Différents exemples d'utilisation</h2>
            <div class="subChapter">
                <h3>
                    1.1. Envoyer un message
                    <img src="images/mail.JPG" alt="mail" align="middle" />
                </h3>
                <p>Voici les différentes étapes à accomplir pour envoyer votre message :</p>
                <p>
                    En premier lieu, il faut créer un objet Properties et récupérez les propriétés du système.
                    <br />
                    Vous devez spécifier le nom de votre serveur smtp aux propriétés (objet
                    <b>Properties</b>
                    ) pour
                    <b>mail.smtp.host</b>
                    .
                </p>
                <p>
                    Envoyer des messages nécessite d'avoir une
                    <i>
                        <b>session</b>
                    </i>
                    . Obtenez la
                    <b>Session</b>
                    objet basé sur
                    <b>Properties</b>
                    .
                    <br />
                    Créez un objet
                    <b>MimeMessage</b>
                    pour la session, et paramétrez ensuite celui-ci avec le sujet, le contenu, les adresses du destinataire et de l'expéditeur.
                    <br />
                    L'envoie du message se termine par la méthode
                    <b>send()</b>
                    de la classe Transport.
                </p>
                <p>
                    <b>Exemple:</b>
                </p>
                <textarea name="code" class="java">String emailfrom = ...;
					String emailto = ...;
					// Récupére les propriétés du systéme
					Properties props = System.getProperties();
					// Spécification du serveur mail
					props.put("mail.smtp.host", host);
					// Récupère la session
					Session session = Session.getDefaultInstance(props, null);
					// Définition du message
					MimeMessage message = new MimeMessage(session);
					//Spécification de l'expéditeur
					message.setFrom(new InternetAddress(emailfrom));
					//Spécification du destinataire
					message.addRecipient(Message.RecipientType.TO, new InternetAddress(emailto));
					//Sujet du message
					message.setSubject("Premier mail");
					//Texte du message
					message.setText("Mon Premier mail");
					// Envoie le message
					Transport.send(message);</textarea>
            </div>
            <div class="subChapter">
                <h3>
                    1.2 Vérification des messages
                    <img src="images/boite.jpg" alt="boite" align="middle" />
                </h3>
                <p>
                    Pour lire vos messages, vous devez récupérer une session, récupérer et se connecter à un objet store qui représente un système de stockage de messages (nous l'appellerons « Messagerie »).
                    <br />
                    Il vous faut ensuite ouvrir le dossier approprié et récupérer vos messages.
                </p>
                <p>Exemple pour le « checking » des messages :</p>
                <textarea name="code" class="java">
                    String host = ...;
					String username = ...;
					String password = ...;
					// Cree un objet Properties
					Properties props = new Properties();
					// Récupère la session
					Session session = Session.getDefaultInstance(props, null);
					// Récupère la "messagerie" et se connecte
					Store store = session.getStore("pop3");
					store.connect(host, username, password);
					// Récupère le fichier "Boite de réception" et l'ouvre
					Folder folder = store.getFolder("INBOX");
					folder.open(Folder.READ_ONLY);
					// Check les messages du dossier
					Message message[] = folder.getMessages();
					//Utilisé pour la lecture
					BufferedReader reader = new BufferedReader ( new InputStreamReader(System.in));
					for (int i=0, n=message.length; i
                    <n i="i" br="br">System.out.println(i + ": " + message[i].getFrom()[0] + "\t" + message[i].getSubject())
						}
						// Pour la lecture du message
						System.out.println("Voulez vous lire le message " [YES to read/QUIT to end]");
						String line = reader.readLine();
						if ("YES".equals(line)) {
						message[i].writeTo(System.out);
						}
						else if ("QUIT";.equals(line)) {
						break;
						}
						// ferme la connection
						folder.close(false);
						store.close();</n>
                </textarea>
            </div>
            <div class="subChapter">
                <h3>
                    1.3 Suppression des messages et « drapeaux »
                    <img src="images/corbeille.jpg" alt="corbeille" align="middle" />
                </h3>
                <p>
                    Supprimer un message nécessite l'utilisation des «
                    <b>drapeaux</b>
                    ».
                    <img src="images/flags.jpg" alt="flags" align="middle" />
                    <br />
                    L'objet
                    <b>Flags</b>
                    (javax.mail.Flags) représente les drapeaux. Ceux-ci sont associés aux messages.
                    <br />
                    En effet chaque message est défini par un état représenté par un «
                    <b>Flag</b>
                    ». Les différents flags sont prédéfinis dans la classe Flags.Flag et sont listés :
                </p>
                <ul>
                    <li>
                        <b>Flags.Flag.ANSWERED :</b>
                        le message a été demandé
                    </li>
                    <li>
                        <b>Flags.Flag.DELETED :</b>
                        message marqué pour la suppression
                    </li>
                    <li>
                        <b>Flags.Flag.DRAFT :</b>
                        le message est un brouillon
                    </li>
                    <li>
                        <b>Flags.Flag.FLAGGED :</b>
                        message marqué dans un état sans définition
                    </li>
                    <li>
                        <b>Flags.Flag.RECENT :</b>
                        message arrivé récemment, non modifiable.
                    </li>
                    <li>
                        <b>Flags.Flag.SEEN :</b>
                        message visualisé
                    </li>
                    <li>
                        <b>Flags.Flag.USER :</b>
                        l'utilisateur peut ajouter des états particuliers.
                    </li>
                </ul>
                <p>
                    Pour supprimer vos messages, vous devez spécifier les «
                    <b>Flag.DELETED</b>
                    »
                </p>
                <textarea name="code" class="java">message.setFlag(Flags.Flag.DELETED, true);</textarea>
                <p>Ouvrez le dossier en READ_WRITE mode :</p>
                <textarea name="code" class="java">folder.open(Folder.READ_WRITE);</textarea>
                <p>
                    Une fois les messages passés au processus, fermez le dossier avec la méthode
                    <b>close()</b>
                    avec comme paramètre true pour effacer les messages.
                </p>
                <textarea name="code" class="java">folder.close(true);</textarea>
            </div>
            <div class="subChapter">
                <h3>
                    1.4 Répondre au message
                    <img src="images/repondre.jpg" alt="repondre" align="middle" />
                </h3>
                <p>
                    La classe
                    <b>Message</b>
                    inclue une méthode
                    <b>reply()</b>
                    pour créer un nouveau message avec les propriétés du message reçu en ajoutant «
                    <b>RE :</b>
                    » dans le sujet.
                </p>
                <p>
                    Pour répondre seulement à l'expéditeur, il faut passer
                    <b>
                        <i>false</i>
                    </b>
                    en paramètre à la méthode
                    <b>reply()</b>
                    .
                </p>
                <textarea name="code" class="java">MimeMessage reply = (MimeMessage)message.reply(false);
					reply.setFrom(new InternetAddress("groupe@ineo.com"));
					reply.setText("Message recu merci");
					Transport.send(reply);</textarea>
            </div>
            <div class="subChapter">
                <h3>
                    1.5 Envoyer un message avec des Pièces jointes
                    <img src="images/trombonne.jpg" alt="trombonne" align="middle" />
                </h3>
                <p>Les pièces jointes sont des ressources qui peuvent être jointes avec un mail. Elles sont souvent placées en dehors des messages comme un fichier texte, une image, une vidéo, un exécutable.</p>
                <p>Comme avec un client de messagerie, on peut aussi attacher une pièce jointe au mail avec les API JavaMail et les ouvrir.</p>
                <p>
                    Pour envoyer une pièce jointe, il faut créer des parties de messages.Chaque partie est créée avec un objet de type
                    <b>MimeBodyPart</b>
                    .
                    <br />
                    La première partie est votre message.
                    <br />
                    Les autres parties correspondent à la pièce jointe.
                    <br />
                    Toutes les parties sont ajoutées dans un objet de type
                    <b>MimeMultipart</b>
                    grâce à la méthode
                    <b>addBodyPart()</b>
                    .
                    <br />
                    Il faut utiliser la classe
                    <b>DataSource</b>
                    pour définir la pièce jointe qui sera un objet de type
                    <b>FileDataSource</b>
                    .
                    <br />
                    La méthode
                    <b>setDataHandler()</b>
                    permet l'ajout de la pièce jointe au message avec la méthode
                    <b>setFileName()</b>
                    pour le nom du fichier.
                </p>
                <p>
                    <b>Exemple:</b>
                </p>
                <textarea name="code" class="java">// Définie le message
					Message message = new MimeMessage(session);
					message.setFrom(new InternetAddress(from));
					message.addRecipient(Message.RecipientType.TO,
					new InternetAddress(to));
					message.setSubject("Pièce jointe");
					// Première partie du message
					BodyPart messageBodyPart = new MimeBodyPart();
					// Contenu du message
					messageBodyPart.setText("le voici");
					//Ajout de la première partie du message dans un objet Multipart
					Multipart multipart = new MimeMultipart();
					multipart.addBodyPart(messageBodyPart);
					// Partie de la pièce jointe
					messageBodyPart = new MimeBodyPart();
					DataSource source = new FileDataSource("image.gif");
					messageBodyPart.setDataHandler(new DataHandler(source));
					messageBodyPart.setFileName("image.gif");
					//Ajout de la partie pièce jointe
					multipart.addBodyPart(messageBodyPart);
					message.setContent(multipart);
					// Envoie du message
					Transport.send(message);</textarea>
            </div>
            <div class="subChapter">
                <h3>1.6 Message HTML</h3>
                <p>
                    Pour envoyer un mail en html, il vous suffit simplement d'écrire votre html dans une string et de le passer au message en lui spécifiant le type et le sous-type du protocole
                    <b>MIME "text/html"</b>
                    .
                </p>
                <textarea name="code" class="java">
                    String htmlText = "
                    <h1>Hello</h1>
                    " + "
                    <img src="\&quot;http://www.labo-java.com/images/logo.gif\&quot;" />
                    ";
					message.setContent(htmlText, "text/html"));
                </textarea>
            </div>
            <div class="subChapter">
                <h3>1.7 Inclure une image au message HTML</h3>
                <p>
                    Si on veut envoyer un message HTML contenant des images alors nous devons traiter le message différemment.
                    <br />
                    En effet, les images doivent être ajoutées en pièces jointes au message. Cependant chaque image doit être référencée par une
                    <b>"cid URL"</b>
                    . cid est la référence du Content-ID (entête de l'image attaché). Ainsi on pourra mettre le lien de l'image dans le HTML par le cid que l'on aura défini.
                </p>
                <p>
                    Le processus reste le même que pour une pièce jointe classique, cependant nous devons indiquer le lien entre les deux parties du message, la partie contenu (html) et l'image. Ceci se fera grâce à
                    <b>"related"</b>
                    passé en paramètre au constructeur de l'objet
                    <b>MultiPart</b>
                    .
                </p>
                <p>
                    <b>Exemple:</b>
                </p>
                <textarea name="code" class="java">
                    String file = ...;
					// Crée le message
					Message message = new MimeMessage(session);
					// On met les attributs d'entête ( sujet, adresse, expéditeur, destinataire)
					message.setSubject("Embedded Image");
					message.setFrom(new InternetAddress(from));
					message.addRecipient(Message.RecipientType.TO,
					new InternetAddress(to));
					// Crée la partie message pour le contenu
					BodyPart messageBodyPart = new MimeBodyPart();
					String htmlText = "
                    <h1>Hello</h1>
                    " +
					"
                    <img src="\&quot;cid:image\&quot;" />
                    ";
					//Type et sous-type du message
					messageBodyPart.setContent(htmlText, "text/html");
					//Crée l'objet Multipart qui contiendra toutes les parties du message
					//on doit passer en paramètre "related", puisque les deux parties entres elles
					//sont reliées
					MimeMultipart multipart = new MimeMultipart("related");
					multipart.addBodyPart(messageBodyPart);
					// Crée l'autre partie du message qui contient l'image
					messageBodyPart = new MimeBodyPart();
					// Place l'image dans la partie
					DataSource fds = new FileDataSource(file);
					messageBodyPart.setDataHandler(new DataHandler(fds));
					//Attribue un nom à l'entête de l'image ( pour faire le lien)
					messageBodyPart.setHeader("Content-ID","
                    <image>");
						// Ajoute la partie à l'objet Multipart
						multipart.addBodyPart(messageBodyPart);
						// Ajoute l'objet Multipart au message
						message.setContent(multipart);</image>
                </textarea>
            </div>
            <div class="subChapter">
                <h3>1.8 Gestion d'une mailing liste</h3>
                <p>Je vais vous montrer la gestion d'une liste de contacts avec l'envoi d'un fichier ou d'un message à ces contacts.</p>
                <p>La plupart des programmes de mail comme Outlook permettent d'envoyer un même message à plusieurs personnes. Il suffit de mettre dans la liste des destinataires les emails des personnes à qui vous souhaitez envoyer ce même message. Malheureusement ceci a la fâcheuse tendance de donner un côté spam au message. JavaMail peut pallier à ce problème, en envoyant le message à plusieurs personnes et de manière individuelle.</p>
                <p>
                    Il va donc falloir créer le message avec le sujet et le contenu.
                    <br />
                    Comme je vous l'ai présenté dans mon premier exemple, voici les règles de création d'un message puis de son envoi :
                </p>
                <ul>
                    <li>
                        Récupération d'une session grâce à
                        <b>Session.getDefaultInstance(props, null)</b>
                        . Cette méthode static prend en paramètre un objet de type
                        <b>Properties</b>
                        qui doit décrire le serveur de mail.
                    </li>
                    <li>
                        Création d'un message de classe
                        <b>MimeMessage</b>
                        . Une fois ce message créé, il faut modifier l'expéditeur, la liste des destinataires, le sujet et le contenu du message, grâce aux méthodes
                        <b>setFrom(), setRecipients(), setSubject() et setContent()</b>
                        .
                    </li>
                    <li>
                        Envoi du message grâce à la méthode static
                        <b>send()</b>
                        de la classe Transport.
                    </li>
                </ul>
                <p>
                    Pour la modification du destinataire, il suffit d'étudier le fichier
                    <b>.txt</b>
                    qui contient la liste des destinataires. Chaque ligne du fichier texte doit contenir un destinataire. On récupère alors chaque destinataire dans une variable de type String dest.
                </p>
                <textarea name="code" class="java">InternetAddress [] address = {new InternetAddress (dest)};
					message.setRecipients (Message.RecipientType.TO, address);</textarea>
                <p>Voici le programme utilisé pour envoyer un message à une liste de contacts :</p>
                <textarea name="code" class="java">import ineo.utilities.*;
					import ineo.metier.*;
					import javax.mail.internet.*;
					import javax.mail.*;
					import java.util.*;
					import java.io.*;
					import javax.mail.internet.InternetAddress;
					public class mail {
					public mail() {
					}
					private final static String MAILER_VERSION = "Java";
					public static void envoyerMailSMTP(String serveur, boolean debug) {
					try {
					Properties prop = System.getProperties();
					prop.put("mail.smtp.host", "smtp.ineo.fr");
					Session session = Session.getDefaultInstance(prop, null);
					Message message = new MimeMessage(session);
					//Modification de l'expéditeur du message
					message.setFrom(new InternetAddress("juliemuesser@ineo.com"));
					// Lecture du fichier txt listeDiffusion afin de récupérer toutes les adresses mails
					String nomFichier = "listeDiffusion.txt";
					FileReader file = new FileReader("nomFichier");
					BufferedReader buf = new BufferedReader(file);
					String adr = buf.readLine();
					// On crée un ArrayList qui contiendra les adresses mails
					ArrayList mesAddresses = new ArrayList();
					while (adr != null) {
					mesAddresses.add(adr);
					adr = buf.readLine();
					}
					InternetAddress[] internetAddresses = null;
					String uneAdresse = "";
					//Modification du destinataire
					for (int i = 0; i
					&lt; mesAddresses.size(); i++) {
					uneAdresse = (String) mesAddresses.get(i);
					internetAddresses[i] = new InternetAddress(uneAdresse);
					}
					message.setRecipients(Message.RecipientType.TO, internetAddresses);
					//Modification des autres propriétés du message
					message.setSubject("Test");
					message.setText("test mail");
					message.setHeader("X-Mailer", MAILER_VERSION);
					message.setSentDate(new Date());
					session.setDebug(debug);
					//envoie du message
					Transport.send(message);
					}
					catch(Exception e)
					{
					e.printStackTrace();
					}
					}
					}</textarea>
            </div>
        </div>
    </body>
</html>

